package com.zyq.chessdemo.demo2;

import lombok.Data;

import javax.swing.*;
import java.awt.*;
import java.io.File;

@Data
public class Chess {

    private static final int SIZE = 30;

    private static final int MARGIN = 20;

    private static final int SPACE = 40;

    private String name;

    private String suffix = ".png";

    protected int player;

    private int x, y;

    // ?
    // 坐标类
    protected Point p;

    // 棋子网格坐标，初始位置，不可改变
    private Point initP;

    // ?
    public void setP(Point p) {
        //
        this.p = (Point) p.clone();
        // ?
        if (initP == null) {
            initP = this.p;
        }
        CalXY();
        // System.out.println("setP  initP ---" + initP);
    }

    /**
     * 判断是否可以走
     *
     * @param tp
     * @return
     */

    public Boolean isAbleMove(Point tp, GamePanel gamePanel) {
        if ("boss".equals(name)) {
            // 田字格内移动
            boolean b = line(tp) > 1 && isHome(tp) && getStep(tp) == 1;
            // System.out.println("b ---" + b);
            return b;
            // return line(tp) > 1 && isHome(tp) && getStep(tp) == 1;

            // if (tp.x < 4 || tp.x > 6) {
            //     return false;
            // }
            // if (initP.y < 6) {
            //     // 上面
            //     if (tp.y > 3 || tp.y < 1) {
            //         return false;
            //     }
            // } else if (initP.y > 5) {
            //     // 下面
            //     if (tp.y > 10 || tp.y < 8) {
            //         return false;
            //     }
            // }
            // // 走直线且只走一步
            // if (p.y == tp.y) {
            //     // x
            //     if (Math.abs(p.x - tp.x) == 1) {
            //         // 走一步
            //         return true;
            //     }
            // } else if (p.x == tp.x) {
            //     // y
            //     if (Math.abs(p.y - tp.y) == 1) {
            //         // 走一步
            //         return true;
            //     }
            // }
        } else if ("shi".equals(name)) {
            // 田字格内移动
            boolean b = line(tp) == 1 && isHome(tp) && getStep(tp) == 1;
            return b;
            // if (tp.x < 4 || tp.x > 6) {
            //     return false;
            // }
            // if (initP.y < 6) {
            //     // 上面
            //     if (tp.y > 3 || tp.y < 1) {
            //         return false;
            //     }
            // } else if (initP.y > 5) {
            //     // 下面
            //     if (tp.y > 10 || tp.y < 8) {
            //         return false;
            //     }
            // }
            // // 走斜线走一步
            // if (Math.abs(p.x - tp.x) == 1 && Math.abs(p.y - tp.y) == 1) {
            //     // 走一步
            //     return true;
            // }
        } else if ("xiang".equals(name)) {

            // 求中心点
            boolean b = line(tp) == 1 && getStep(tp) == 2 && !isBieJao(tp, gamePanel) && isOverRiver(tp);
            System.out.println("xiang-b ---" + b);
            return b;
        } else if ("ma".equals(name)) {
            return (line(tp) == 0 || line(tp) == -1) && !isBieJao(tp, gamePanel);
        } else if ("che".equals(name)) {
            return line(tp) > 1 && getCount(tp, gamePanel) == 0;
        }
        return false;
    }

    /**
     * 判断棋子初始是上还是下
     *
     * @return 1、上面
     * 2、下面
     */
    public int isUpOrDown() {
        if (initP.y < 6) {
            // 上面
            return 1;
        } else if (initP.y > 5) {
            // 下面
            return 2;
        }
        return 0;
    }

    /**
     * 判断棋子是否在田字格内
     *
     * @param tp
     * @return
     */
    public boolean isHome(Point tp) {
        if (tp.x < 4 || tp.x > 6) {
            return false;
        }
        int upOrDown = isUpOrDown();
        // if (initP.y < 6) {
        if (upOrDown == 1) {
            // 上面
            if (tp.y > 3 || tp.y < 1) {
                return false;
            }
        } else if (upOrDown == 2) {
            // 下面
            if (tp.y > 10 || tp.y < 8) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断走直线还是斜线
     *
     * @param tp
     * @return 1、x移动
     */
    public int line(Point tp) {
        if (p.y == tp.y) {
            // x移动
            return 3;
            // return 1;
        } else if (p.x == tp.x) {
            // y移动
            return 2;
        } else if (Math.abs(p.x - tp.x) == Math.abs(p.y - tp.y)) {
            // 正斜线
            return 1;
            // return 3;
        } else {
            // 日字
            if (Math.abs(p.x - tp.x) == 2 && Math.abs(p.y - tp.y) == 1) {
                // x
                return 0;
            } else if (Math.abs(p.x - tp.x) == 1 && Math.abs(p.y - tp.y) == 2) {
                // y
                return -1;
            }
        }
        return 0;
    }

    /**
     * 计算起点到目标点之间的步数
     *
     * @param tp
     * @return
     */
    public int getStep(Point tp) {

        int line = line(tp);
        if (line == 3) {
            return Math.abs(p.x - tp.x);
        } else if (line == 2) {
            return Math.abs(p.y - tp.y);
        } else if (line == 1) {
            // 正斜线
            // ？
            return Math.abs(p.y - tp.y);
        }
        return 0;
    }

    /**
     * 判断相或马是否蹩脚
     *
     * @param tp
     * @param gamePanel
     * @return
     */
    public boolean isBieJao(Point tp, GamePanel gamePanel) {
        Point center = new Point();
        if ("xiang".equals(name)) {
            // 起始点+落子点
            center.x = (p.x + tp.x) / 2;
            center.y = (p.y + tp.y) / 2;
            // ?
            return gamePanel.getChessByP(center) != null;
            // if (gamePanel.getChessByP(center) == null) {
            //     System.out.println("center1 ---" + center);
            //     return true;
            // } else if (gamePanel.getChessByP(center) != null) {
            //     System.out.println("center2 ---" + center);
            //     return false;
            // }
        } else if ("ma".equals(name)) {

            int line = line(tp);
            if (line == 0) {
                // x
                center.x = (p.x + tp.x) / 2;
                center.y = p.y;
            } else if (line == -1) {
                // y
                center.y = (p.y + tp.y) / 2;
                center.x = p.x;
            }
            return gamePanel.getChessByP(center) != null;

        }
        return true;
    }

    /**
     * 判断是否过河
     *
     * @param tp
     * @return
     */
    public boolean isOverRiver(Point tp) {
        int upOrDown = isUpOrDown();
        if (upOrDown == 1) {
            // 上面
            if (tp.y > 5) {
                return false;
            }
        } else if (upOrDown == 2) {
            // 下面
            if (tp.y < 6) {
                return false;
            }
        }
        return true;
    }

    /**
     * 计算起点到目标点之间的棋子数量，不计算起点和目标点上的位置
     *
     * @param tp
     * @return
     */
    public int getCount(Point tp, GamePanel gamePanel) {
        int start = 0;
        int end = 0;
        int count = 0;// 统计棋子数量
        int line = line(tp);
        Point np = new Point();
        if (line == 2) {
            // y
            np.x = tp.x;
            if (tp.y > p.y) {
                // 从上往下
                start = p.y + 1;
                end = tp.y;
            } else {
                // 从下往上
                start = tp.y + 1;
                end = p.y;
            }
            for (int i = start; i < end; i++) {
                np.y = i;
                if (gamePanel.getChessByP(np) != null) {
                    count++;
                }
            }
        } else if (line == 3) {
            // x
            np.y = tp.y;
            if (tp.x > p.x) {
                // 从左往右
                start = p.x + 1;
                end = tp.x;
            } else {
                // 从右往左
                start = tp.x + 1;
                end = p.x;
            }
            System.out.println("start:" + start);
            System.out.println("end:" + end);
            for (int i = start; i < end; i++) {
                np.x = i;
                if (gamePanel.getChessByP(np) != null) {
                    count++;
                }
            }
        }
        System.out.println("棋子总数：" + count);
        return count;
    }


    /**
     * 画棋子
     *
     * @param g
     * @param panel
     */
    public void draw(Graphics g, JPanel panel) {

        String path = "pic" + File.separator + name + player + suffix;
        Image img = Toolkit.getDefaultToolkit().getImage(path);
        g.drawImage(img, x, y, SIZE, SIZE, panel);
    }

    /**
     * 画棋子边框
     *
     * @param g
     */
    public void drawRect(Graphics g) {

        g.drawRect(x, y, SIZE, SIZE);
    }

    public void CalXY() {
        x = MARGIN - SIZE / 2 + SPACE * (p.x - 1);
        y = MARGIN - SIZE / 2 + SPACE * (p.y - 1);
        // System.out.println("p.x:" + p.x + " p.y:" + p.y);
        // System.out.println("x:" + x + " y:" + y);
    }

    public void reserve() {
        // 和下面的区别
        // x = MARGIN - SIZE / 2 + SPACE * (10 - p.x - 1);
        // y = MARGIN - SIZE / 2 + SPACE * (11 - p.y - 1);

        p.x = 10 - p.x;
        p.y = 11 - p.y;
        // ?
        initP = p;
        CalXY();
        // System.out.println("reserve  initP ---" + initP);
    }

    /**
     * 根据坐标获取点
     *
     * @param x
     * @param y
     * @return
     */
    public static Point getPointFromXY(int x, int y) {
        Point p = new Point();
        p.x = (x - MARGIN + SIZE / 2) / SPACE + 1;
        p.y = (y - MARGIN + SIZE / 2) / SPACE + 1;
        // System.out.println("p.x:" + p.x + " p.y:" + p.y);
        // 边界判断
        if (p.x < 1 || p.x > 9 || p.y < 1 || p.y > 10) {
            return null;
        }
        return p;
    }


}


